Electronics devices and capabilities have grown extremely common in daily life. Along with personal computers in the home, many individuals carry more than one productivity tool for various and sundry purposes. Most personal productivity electronic devices include some form of non-volatile memory. Cell phones utilize non-volatile memory in order to store and retain user programmed phone numbers and configurations when the power is turned off. PCMCIA cards utilize non-volatile memory to store and retain information even when the card is removed from its slot in the computer. Many other common electronic devices also benefit from the long-term storage capability of non-volatile memory in un-powered assemblies.
Non-volatile memory manufacturers that sell to the electronic equipment manufacturers require testers to exercise and verify the proper operation of the memories that they produce. Due to the volume of non-volatile memories that are manufactured and sold at consistently low prices, it is very important to minimize the time it takes to test a single part. Purchasers of non-volatile memories require memory manufacturers to provide high shipment yields because of the cost savings associated with the practice of incorporating the memory devices into more expensive assemblies with minimal or no testing. Accordingly, the memory testing process must be sufficiently efficient to identify a large percentage of non-conforming parts and preferably all non-conforming parts in a single test process.
As non-volatile memories become larger, denser and more complex, the testers must be able to handle the increased size and complexity without significantly increasing the time it takes to test them. As memories evolve and improve, the tester must be able to easily accommodate the changes made to the device. Another issue specific to testing non-volatile memories is that repeated writes to cells of the memories can degrade the overall lifetime performance of the part. Non-volatile memory manufacturers have responded to many of the testing issues by building special test modes into the memory devices. These test modes are not used at all by the purchaser of the memory, but may be accessed by the manufacturer to test all or significant portions of the memories in as little time as possible and as efficiently as possible. Some non-volatile memories are also capable of being repaired during the test process. The tester, therefore, should be able to identify: a need for repair; a location of the repair; the type of repair needed; and, must then be able to perform the appropriate repair. Such a repair process requires a tester that is able to detect and isolate a specific nonconforming portion of the memory. In order to take full advantage of the special test modes as well as the repair functions, it is beneficial for a tester to be able to execute a test program that supports conditional branching based upon an expected response from the device.
From a conceptual perspective, the process of testing memories is an algorithmic process. As an example, typical tests include sequentially incrementing or decrementing memory addresses while writing 0""s and 1""s into the memory cells. It is customary to refer to a collection of 1""s and 0""s being written or read during a memory cycle as a xe2x80x9cvectorxe2x80x9d, while the term xe2x80x9cpatternxe2x80x9d refers to a sequence of vectors. It is conventional for tests to include writing patterns into the memory space such as checkerboards, walking 1""s and butterfly patterns. A test developer can more easily and efficiently generate a program to create these patterns with the aid of algorithmic constructs. A test pattern that is algorithmically coherent is also easier to debug and use logical methods to isolate portions of the pattern that do not perform as expected. A test pattern that is generated algorithmically using instructions and commands that are repeated in programming loops consume less space in tester memory. Accordingly, it is desirable to have algorithmic test pattern generation capability in a memory tester.
Precise signal edge placement and detection is also a consideration in the effectiveness of a non-volatile tester. In order to capture parts that are generally conforming at a median while not conforming within the specified margins, a non-volatile memory tester must be able to precisely place each signal edge relative in time to another signal edge. It is also important to be able to precisely measure at which point in time a signal edge is received. Accordingly, a non-volatile memory tester should have sufficient flexibility and control of the timing and placement of stimuli and responses from the Device Under Test (memory).
Memory testers are said to generate transmit vectors that are applied (stimulus) to the DUT, and receive vectors that are expected in return (response). The algorithmic logic that generates these vectors can generally do so without troubling itself about how a particular bit in a vector is to get to or from a particular signal pad in the DUT. At this level it is almost as if it were a certainty that adjacent bits in the vector would end up as physically adjacent signals on the DUT. Life should be so kind!
In reality, the correspondence between bits in a vector at the xe2x80x9cconceptual levelxe2x80x9d and the actual signals in the DUT is apt to be rather arbitrary. If nothing were done to prevent it, it might be necessary to cross one or more probe wires as they descend from a periphery to make contact with the DUT. Such crossing is most undesirable, and it is convention to incorporate a mapping mechanism in the path of the transmit vector to rearrange the bit positions in the transmit vector before they are applied to the DUT, so that task of making physical contact is not burdened with crossings. Receive vectors are correspondingly applied to a reverse mapping mechanism before being considered. In this way the algorithmic vector generation and comparison mechanisms can be allowed to ignore this entire issue. As another example of what such mappers and reverse mappers can do, consider the case when a different instance of the same type of DUT is laid out on the same wafer, but with a rotation or some mirrored symmetry, in order to avoid wasting space on the wafer. These practices also have an effect on the correspondence between vector bit position and physical signal location, but which can be concealed by the appropriate mappings and reverse mappings. It will be appreciated that the mappings and reverse mappings needed for these situations are, once identified for a particular DUT, static, and need not change during the course of testing for that particular DUT.
As part of a testing process, it is desirable to store information relevant to performance of a device under test (DUT) during a test pattern. After completion of the test pattern, the stored data is retrieved and evaluated for purposes of repair of a device or insights into overall test objectives. Some examples of relevant information to store are a number of errors detected within a page of memory and beginning and ending addresses of cells within a memory that exhibited errors during testing. It is also desirable to write to certain registers and memories within the tester in order to modify a current state of the tester or program look up tables present in the tester. In order to minimize any impact that data storage might have on overall test time, it is also desirable to be able to perform these administrative tasks during an instruction cycle that is part of the test itself. For purposes of the present disclosure, the term xe2x80x9cvectorxe2x80x9d is used to reference a parallel group of 1""s and 0""s applied to drive or receive channels connected to the DUT. The term xe2x80x9cinstructionxe2x80x9d is used to reference a line of software within the test pattern executed by the DUT tester. xe2x80x9cVectorxe2x80x9d and xe2x80x9cinstructionxe2x80x9d are used interchangeably because each instruction executed by the tester generates a vector that is applied to the DUT.
Prior art testers accomplish data storage during a test pattern by dedicating one or more counters to administer the count or recording of data that the tester stores at a later time. One or more counters might also be needed to maintain an address location into which the data is stored. To store the data, the data from the one or more data and address counters is placed on an appropriate bus and then is loaded into memory. Conventionally, the memory is located in a different processor. Disadvantageously, dedication of one or more counters to the data tracking function decreases test developer flexibility by displacing its use for another possible task. Additionally, the process of storing the counter data to memory requires more than one vector thereby lengthening test time with administrative functions.
There is a need, therefore, for a syntax and hardware assist to administer accumulation of data relevant to the testing function without increasing test time and without displacing memory tester tools.
An apparatus for automatically accumulating and storing information comprises a destination memory and an indexing circuit. The indexing circuit comprises an input port, a selector having a selector output, a register holding a value from said selector output and presenting the selector output value at a register output, and an accumulator accepting a value from the input port and a value from the register output and presenting a sum of the input port and register output values at an accumulator output. The selector receives the input port value from the input port, the accumulator output, and the value from the register output, the selector output being based upon a programmable selection code. The register output is connected to the destination memory.
A method for storing information comprises the steps of fetching a program instruction word, the program instruction word comprising a first segment and a second segment and executing the first segment and the second segment. The step of executing the second segment comprises the steps of presenting a value to an indexing circuit, presenting a selection code to the indexing circuit, and accessing a destination memory with an output of the indexing circuit.